import 'package:dio/dio.dart' as dio;
import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import '../services/dio_service.dart';
import '../models/index.dart';

/// 用户API调用类
/// 
/// 负责所有用户相关的API调用
/// 使用DioService进行网络请求，返回标准化的ApiResponse
/// 这是一个工具类，不是服务类
class UserApi {
  // 🔗 API路径常量
  static const String sendSMSPath = '/v1/auth/sendSMS'; // 发送验证码接口
  static const String loginPath = '/v1/auth/login';
  static const String logoutPath = '/v1/auth/logout';
  static const String refreshTokenPath = '/v1/auth/refreshToken'; // 修正路径
  static const String expertInfoPath = '/v1/auth/expertInfo';
  static const String expertReviewPath = '/v1/app/expertReview'; // 专家评审/验收接口
  
  // 投票选举相关接口
  static const String voteTeamLeaderPath = '/v1/app/voteTeamLeader'; // 专家组长投票选举
  static const String checkVotedPath = '/v1/app/checkVoted'; // 检查专家投票状态
  static const String voteNumPath = '/v1/app/voteNum'; // 获取投票统计信息
  static const String mostVotesExpertIdPath = '/v1/app/mostVotesExpertId'; // 获取得票最多的专家ID
  
  // 📡 网络服务实例
  static DioService get _dioService => Get.find<DioService>();
  
  /// 发送短信验证码API
  /// 
  /// [phone] 手机号
  /// 返回是否发送成功
  static Future<bool> sendSMS(String phone) async {
    debugPrint('📱 UserApi.sendSMS 开始调用');
    debugPrint('📱 手机号: $phone');
    
    try {
      // 根据API文档，使用GET请求，参数在URL中
      final response = await _dioService.get(
        sendSMSPath,
        queryParameters: {'phone': phone},
      );
      
      debugPrint('📱 发送验证码请求完成，状态码: ${response.statusCode}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        debugPrint('📱 发送验证码响应数据: $responseData');
        
        // 检查响应状态码
        final code = responseData['code']?.toInt() ?? -1;
        final message = responseData['message']?.toString() ?? responseData['msg']?.toString();
        
        if (code == 200) { // API文档显示成功时code为200
          debugPrint('✅ 验证码发送成功');
          return true;
        } else {
          // 业务失败响应
          debugPrint('❌ 验证码发送失败: $message');
          throw Exception(message ?? '验证码发送失败');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ UserApi.sendSMS异常: $e');
      rethrow;
    }
  }
  
  /// 手机号验证码登录API
  /// 
  /// [phone] 手机号
  /// [captcha] 验证码（测试环境可随意输入）
  /// 直接返回TokenModel
  static Future<TokenModel> login(String phone, String captcha) async {
    debugPrint('🔐 UserApi.login 开始调用');
    debugPrint('🔐 手机号: $phone');
    debugPrint('🔐 验证码: $captcha');
    
    try {
      // 根据API文档，使用 application/x-www-form-urlencoded 格式
      final formData = <String, String>{
        'phone': phone,
        'captcha': captcha,
      };
      
      debugPrint('🔐 发送form-data请求到: $loginPath');
      
      // 使用DioService发送请求，指定content-type为form-urlencoded
      final response = await _dioService.post(
        loginPath,
        data: formData,
        options: dio.Options(
          contentType: 'application/x-www-form-urlencoded',
        ),
      );
      
      debugPrint('🔐 登录请求完成，状态码: ${response.statusCode}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        debugPrint('🔐 登录响应数据: $responseData');
        
        // 检查响应状态码
        final code = responseData['code']?.toInt() ?? -1;
        final message = responseData['message']?.toString() ?? responseData['msg']?.toString();
        
        if (code == 200 || code == 0) { // API文档显示成功时code为200或0
          // 成功响应 - 解析data字段为TokenModel
          final data = responseData['data'];
          if (data != null && data is Map<String, dynamic>) {
            final tokenModel = TokenModel.fromJson(data);
            
            debugPrint('✅ 登录成功，解析TokenModel完成');
            debugPrint('🔐 AccessToken长度: ${tokenModel.accessToken.length}');
            
            return tokenModel;
          } else {
            debugPrint('❌ Token数据格式错误');
            throw Exception('Token数据格式错误');
          }
        } else {
          // 业务失败响应
          debugPrint('❌ 登录失败: $message');
          throw Exception(message ?? '登录失败，请重试');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ UserApi.login异常: $e');
      rethrow;
    }
  }
  
  /// 刷新访问令牌API
  /// 
  /// [refreshToken] 刷新令牌
  /// 直接返回新的TokenModel
  static Future<TokenModel> refreshToken(String refreshToken) async {
    debugPrint('🔄 UserApi.refreshToken开始调用');
    debugPrint('🔄 刷新令牌长度: ${refreshToken.length}');
    
    try {
      // 根据API文档，使用 application/x-www-form-urlencoded 格式
      // 参数名为 token (不是 refreshToken)
      final formData = <String, String>{
        'token': refreshToken,  // 注意：参数名是 token，不是 refreshToken
      };
      
      debugPrint('🔄 发送form-data请求到: $refreshTokenPath');
      debugPrint('🔄 请求数据: $formData');
      
      // 使用DioService发送请求，指定content-type为form-urlencoded
      final response = await _dioService.post(
        refreshTokenPath,
        data: formData,
        options: dio.Options(
          contentType: 'application/x-www-form-urlencoded',
        ),
      );
      
      debugPrint('🔄 刷新令牌请求完成，状态码: ${response.statusCode}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        debugPrint('🔄 刷新令牌响应数据: $responseData');
        
        // 检查响应状态码
        final code = responseData['code']?.toInt() ?? -1;
        final msg = responseData['message']?.toString() ?? responseData['msg']?.toString();
        
        if (code == 0) { // API文档显示成功时code为0（和登录API一致）
          // 成功响应 - 解析data字段为TokenModel
          final data = responseData['data'];
          if (data != null && data is Map<String, dynamic>) {
            final tokenModel = TokenModel.fromJson(data);
            
            debugPrint('✅ 刷新令牌成功，解析TokenModel完成');
            debugPrint('🔄 新AccessToken长度: ${tokenModel.accessToken.length}');
            
            return tokenModel;
          } else {
            debugPrint('❌ Token数据格式错误');
            throw Exception('Token数据格式错误');
          }
        } else {
          // 业务失败响应
          debugPrint('❌ 刷新令牌失败: $msg');
          throw Exception(msg ?? '刷新令牌失败，请重新登录');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ UserApi.refreshToken异常: $e');
      rethrow;
    }
  }
  
  /// 获取专家信息API
  /// 
  /// 使用DioService自动携带的token获取当前登录专家的详细信息
  /// 直接返回ExpertInfo
  static Future<ExpertInfo> getExpertInfo() async {
    try {
      debugPrint('🔄 开始获取专家信息');
      
      // 使用DioService发送GET请求，token会被自动添加到请求头
      // 错误处理由DioService统一处理，不在此处重复处理
      final response = await _dioService.get(expertInfoPath);
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        // 检查响应状态码
        final code = responseData['code']?.toInt() ?? -1;
        final msg = responseData['message']?.toString() ?? responseData['msg']?.toString();
        
        if (code == 0) { // 专家信息API成功时code为0
          // 成功响应 - 解析data字段为ExpertInfo
          final data = responseData['data'];
          if (data != null && data is Map<String, dynamic>) {
            final expertInfo = ExpertInfo.fromJson(data);
            
            debugPrint('✅ 获取专家信息成功: ${expertInfo.name}');
            
            return expertInfo;
          } else {
            debugPrint('❌ 专家信息数据格式错误');
            throw Exception('专家信息数据格式错误');
          }
        } else {
          // 业务失败响应
          debugPrint('❌ 获取专家信息失败: $msg');
          throw Exception(msg ?? '获取专家信息失败');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ 获取专家信息异常: $e');
      rethrow;
    }
  }
  
  /// 专家评审/验收API
  /// 
  /// 专家对项目进行评审或验收操作，提交评审/验收意见和结果
  /// 
  /// [expertId] 专家ID
  /// [projectId] 项目ID
  /// [projectStatus] 项目当前状态：2-待评审，12-待专家终验验收
  /// [reviewStatus] 评审/验收状态：1-未通过，2-通过
  /// [note] 评审/验收意见
  /// [isLeader] 是否是组长提交（0-否，1-是），默认为0
  /// 
  /// 返回是否成功
  static Future<bool> expertReview({
    required int expertId,
    required int projectId,
    required int projectStatus,
    required int reviewStatus,
    required String note,
    int isLeader = 0,
  }) async {
    debugPrint('📝 UserApi.expertReview 开始调用');
    debugPrint('📝 专家ID: $expertId, 项目ID: $projectId');
    debugPrint('📝 项目状态: $projectStatus, 评审状态: $reviewStatus');
    debugPrint('📝 是否组长: $isLeader');
    
    try {
      // 根据API文档，使用 application/x-www-form-urlencoded 格式
      final formData = <String, dynamic>{
        'expertId': expertId,
        'projectId': projectId,
        'projectStatus': projectStatus,
        'reviewStatus': reviewStatus,
        'note': note,
        'isLeader': isLeader,
      };
      
      debugPrint('📝 发送form-data请求到: $expertReviewPath');
      debugPrint('📝 请求参数: $formData');
      
      // 使用DioService发送请求，指定content-type为form-urlencoded
      final response = await _dioService.post(
        expertReviewPath,
        data: formData,
        options: dio.Options(
          contentType: 'application/x-www-form-urlencoded',
        ),
      );
      
      debugPrint('📝 专家评审请求完成，状态码: ${response.statusCode}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        debugPrint('📝 专家评审响应数据: $responseData');
        
        // 检查响应状态码
        final code = responseData['code']?.toInt() ?? -1;
        final msg = responseData['msg']?.toString();
        
        if (code == 0) { // API文档显示成功时code为0
          debugPrint('✅ 专家评审提交成功');
          return true;
        } else {
          // 业务失败响应
          debugPrint('❌ 专家评审提交失败: $msg');
          throw Exception(msg ?? '评审提交失败，请重试');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ UserApi.expertReview异常: $e');
      rethrow;
    }
  }
  
  /// 专家组长投票选举API
  /// 
  /// 专家对项目组长进行投票。每个专家在一个项目下只能投票一次。
  /// 
  /// [projectId] 项目ID
  /// [voterId] 选举人专家ID（当前登录专家ID）
  /// [beVotedId] 被选举专家ID
  /// [voteFlag] 选举类型：0-评审（默认），1-验收
  /// 
  /// 返回是否成功
  static Future<bool> voteTeamLeader({
    required int projectId,
    required int voterId,
    required int beVotedId,
    int voteFlag = 0,
  }) async {
    debugPrint('🗳️ UserApi.voteTeamLeader 开始调用');
    debugPrint('🗳️ 项目ID: $projectId, 选举人ID: $voterId, 被选举人ID: $beVotedId, 选举类型: $voteFlag');
    
    try {
      // 根据API文档，使用POST请求，参数在URL中
      final response = await _dioService.post(
        voteTeamLeaderPath,
        queryParameters: {
          'projectId': projectId,
          'voterId': voterId,
          'beVotedId': beVotedId,
          'voteFlag': voteFlag,
        },
      );
      
      debugPrint('🗳️ 投票请求完成，状态码: ${response.statusCode}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        debugPrint('🗳️ 投票响应数据: $responseData');
        
        // 检查响应状态码
        final code = responseData['code']?.toInt() ?? -1;
        final message = responseData['message']?.toString() ?? responseData['msg']?.toString();
        
        if (code == 200 || code == 0) { // 接口可能返回0或200表示成功
          debugPrint('✅ 投票成功');
          return true;
        } else {
          // 业务失败响应
          debugPrint('❌ 投票失败: $message');
          throw Exception(message ?? '投票失败，请重试');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ UserApi.voteTeamLeader异常: $e');
      rethrow;
    }
  }
  
  /// 检查专家投票状态API
  /// 
  /// 检查当前登录专家是否已在指定项目和选举类型下投过组长选举票
  /// 
  /// [projectId] 项目ID
  /// [voterId] 选举人专家ID（当前登录专家ID）
  /// [voteFlag] 选举类型：0-评审（默认），1-验收
  /// 
  /// 返回true表示已投票，false表示未投票
  static Future<bool> checkVoted({
    required int projectId,
    required int voterId,
    int voteFlag = 0,
  }) async {
    debugPrint('🔍 UserApi.checkVoted 开始调用');
    debugPrint('🔍 项目ID: $projectId, 选举人ID: $voterId, 选举类型: $voteFlag');
    
    try {
      // 根据API文档，使用GET请求，参数在URL中
      final response = await _dioService.get(
        checkVotedPath,
        queryParameters: {
          'projectId': projectId,
          'voterId': voterId,
          'voteFlag': voteFlag,
        },
      );
      
      debugPrint('🔍 检查投票状态请求完成，状态码: ${response.statusCode}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        debugPrint('🔍 检查投票状态响应数据: $responseData');
        
        // 检查响应状态码
        final code = responseData['code']?.toInt() ?? -1;
        final message = responseData['message']?.toString() ?? responseData['msg']?.toString();
        
        if (code == 200 || code == 0) { // 接口可能返回0或200表示成功
          final voted = responseData['data'] as bool? ?? false;
          debugPrint('✅ 投票状态查询成功: ${voted ? "已投票" : "未投票"}');
          return voted;
        } else {
          // 业务失败响应
          debugPrint('❌ 投票状态查询失败: $message');
          throw Exception(message ?? '投票状态查询失败');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ UserApi.checkVoted异常: $e');
      rethrow;
    }
  }
  
  /// 获取投票统计信息API
  /// 
  /// 获取指定项目下参与选举的专家总数，以及已投过票的专家总数
  /// 
  /// [projectId] 项目ID
  /// [voteFlag] 选举类型：0-评审（默认），1-验收
  /// 
  /// 返回Map包含expertNum（专家总数）和votedNum（已投票数）
  static Future<Map<String, int>> getVoteNum({
    required int projectId,
    int voteFlag = 0,
  }) async {
    debugPrint('📊 UserApi.getVoteNum 开始调用');
    debugPrint('📊 项目ID: $projectId, 选举类型: $voteFlag');
    
    try {
      // 根据API文档，使用GET请求，参数在URL中
      final response = await _dioService.get(
        voteNumPath,
        queryParameters: {
          'projectId': projectId,
          'voteFlag': voteFlag,
        },
      );
      
      debugPrint('📊 获取投票统计请求完成，状态码: ${response.statusCode}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        debugPrint('📊 投票统计响应数据: $responseData');
        
        // API直接返回expertNum和votedNum，不包装在code中
        final expertNum = (responseData['expertNum'] as num?)?.toInt() ?? 0;
        final votedNum = (responseData['votedNum'] as num?)?.toInt() ?? 0;
        
        debugPrint('✅ 投票统计查询成功: 专家总数=$expertNum, 已投票=$votedNum');
        
        return {
          'expertNum': expertNum,
          'votedNum': votedNum,
        };
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ UserApi.getVoteNum异常: $e');
      rethrow;
    }
  }
  
  /// 获取得票最多的专家ID API
  /// 
  /// 获取指定项目和选举类型下，获得票数最多的专家ID
  /// 
  /// [projectId] 项目ID
  /// [voteFlag] 选举类型：0-评审（默认），1-验收
  /// 
  /// 返回得票最多的专家ID，如果无投票或平票则返回0
  static Future<int> getMostVotesExpertId({
    required int projectId,
    int voteFlag = 0,
  }) async {
    debugPrint('🏆 UserApi.getMostVotesExpertId 开始调用');
    debugPrint('🏆 项目ID: $projectId, 选举类型: $voteFlag');
    
    try {
      // 根据API文档，使用GET请求，参数在URL中
      final response = await _dioService.get(
        mostVotesExpertIdPath,
        queryParameters: {
          'projectId': projectId,
          'voteFlag': voteFlag,
        },
      );
      
      debugPrint('🏆 获取得票最多专家请求完成，状态码: ${response.statusCode}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        debugPrint('🏆 得票最多专家响应数据: $responseData');
        
        // 检查响应状态码
        final code = responseData['code']?.toInt() ?? -1;
        final message = responseData['message']?.toString() ?? responseData['msg']?.toString();
        
        if (code == 200 || code == 0) { // 接口可能返回0或200表示成功
          final expertId = (responseData['data'] as num?)?.toInt() ?? 0;
          debugPrint('✅ 得票最多专家查询成功: expertId=$expertId');
          return expertId;
        } else {
          // 业务失败响应
          debugPrint('❌ 得票最多专家查询失败: $message');
          throw Exception(message ?? '得票最多专家查询失败');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ UserApi.getMostVotesExpertId异常: $e');
      rethrow;
    }
  }
  
}
